// src/main/java/org/example/demo1/service/PodCPUMemoryTools.java

package org.example.demo1.service;

// 删除原有的 Config, DefaultKubernetesClient 导入，如果它们不再直接使用
// import io.fabric8.kubernetes.client.Config;
// import io.fabric8.kubernetes.client.DefaultKubernetesClient;

import io.fabric8.kubernetes.api.model.Container;
import io.fabric8.kubernetes.api.model.Pod;
import io.fabric8.kubernetes.api.model.Quantity;
import io.fabric8.kubernetes.api.model.ResourceRequirements;
import io.fabric8.kubernetes.api.model.metrics.v1beta1.PodMetricsList;
import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.tool.annotation.Tool;
import org.springframework.stereotype.Service;

import io.fabric8.kubernetes.client.KubernetesClient;
import io.fabric8.kubernetes.client.KubernetesClientException;
import io.fabric8.kubernetes.api.model.metrics.v1beta1.PodMetrics;
import io.fabric8.kubernetes.api.model.metrics.v1beta1.ContainerMetrics;

// 新增导入 KubernetesClientUtil
import org.example.demo1.util.KubernetesClientUtil; // 根据你的实际包路径调整

// 删除不再需要的导入
// import java.io.File;
// import java.io.IOException;
// import java.nio.file.Files;


import java.util.List;
import java.time.format.DateTimeFormatter;
import java.time.ZoneId;
import java.time.Instant;        // 可能需要，但主要是 ZonedDateTime
import java.time.ZonedDateTime;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.Optional;


@Service
@Slf4j
public class PodCPUMemoryTools {

    /*
    1.获取指定Pod的实时CPU和内存使用量及百分比，并对高使用率进行提醒
    2.获取指定Pod的CPU和内存的请求（requests）和限制（limits）配置。
    3.增加指定Pod中容器的CPU请求和/或限制。这有助于解决因CPU资源不足导致的Pod性能问题或崩溃
    4.增加指定Pod中容器的内存请求和/或限制。这有助于解决因内存不足导致的Pod崩溃（OOMKilled）或性能问题

     */

    // KUBECONFIG_PATH 等常量现在移到 KubernetesClientUtil 中，这里不再需要定义
    // private static final String KUBECONFIG_PATH = "E:\\whu-ops\\src\\main\\resources\\templates\\config";
    // private static final int CONNECTION_TIMEOUT = 10;
    // private static final int REQUEST_TIMEOUT = 15;

    private static final String DEFAULT_NAMESPACE = "online-boutique";


// ... (其他必要的导入，例如 lombok.extern.slf4j.Slf4j, org.springframework.ai.tool.annotation.Tool) ...

    @Tool(description = "获取指定Pod的实时CPU和内存使用量及百分比，并对高使用率进行提醒。这有助于快速识别哪些Pod或容器的资源使用异常高。")
    public String getPodResourceUsage(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("📊 获取 Pod 资源使用情况及百分比 - {}:{}", targetNamespace, podName);

        try {
            if (!KubernetesClientUtil.testConnection()) {
                return "❌ **集群连接失败**，无法获取 Pod 资源使用情况。请检查 Kubernetes Metrics Server 是否已安装并运行。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                PodMetrics podMetrics = client.top().pods().inNamespace(targetNamespace).withName(podName).metric();
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get(); // 获取 Pod 对象以获取请求和限制

                if (podMetrics == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在，或者 Metrics Server 未收集到其数据**。请确认 Pod 存在且 Metrics Server 正常运行。", podName, targetNamespace);
                }
                if (pod == null) {
                    return String.format("❌ **无法获取 Pod '%s' 在命名空间 '%s' 中的配置信息**。请确认 Pod 存在。", podName, targetNamespace);
                }

                StringBuilder result = new StringBuilder();
                result.append(String.format("📈 **Pod 资源使用概览**: %s (命名空间: %s)\n\n", podName, targetNamespace));

                // 获取 Pod 的整体 CPU 和内存使用量 (保持不变)
                String overallCpu = (podMetrics.getContainers() != null) ?
                        podMetrics.getContainers().stream()
                                .map(cm -> cm.getUsage().get("cpu") != null ? cm.getUsage().get("cpu").getAmount() : "0")
                                .collect(java.util.stream.Collectors.joining(" + ")) : "N/A";
                String overallMemory = (podMetrics.getContainers() != null) ?
                        podMetrics.getContainers().stream()
                                .map(cm -> cm.getUsage().get("memory") != null ? cm.getUsage().get("memory").getAmount() : "0")
                                .collect(java.util.stream.Collectors.joining(" + ")) : "N/A";

                result.append(String.format("📊 **Pod 整体使用**: CPU: %s, 内存: %s\n", overallCpu, overallMemory));
                result.append(String.format("⏱️ **数据采集时间**: %s\n\n",
                        (podMetrics.getTimestamp() != null) ?
                                ZonedDateTime.parse(podMetrics.getTimestamp())
                                        .withZoneSameInstant(ZoneId.systemDefault())
                                        .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z")) : "N/A"));

                if (podMetrics.getContainers() != null && !podMetrics.getContainers().isEmpty()) {
                    result.append("**各容器资源使用详情**:\n");
                    for (ContainerMetrics containerMetrics : podMetrics.getContainers()) {
                        String containerName = containerMetrics.getName();
                        String cpuUsageAmount = containerMetrics.getUsage().get("cpu") != null ? containerMetrics.getUsage().get("cpu").getAmount() : "0";
                        String memoryUsageAmount = containerMetrics.getUsage().get("memory") != null ? containerMetrics.getUsage().get("memory").getAmount() : "0";

                        // 查找对应的容器配置，以获取请求和限制
                        Optional<Container> containerConfigOpt = pod.getSpec().getContainers().stream()
                                .filter(c -> c.getName().equals(containerName))
                                .findFirst();

                        result.append(String.format("- **容器 '%s'**:\n", containerName));
                        result.append(String.format("  CPU: %s, 内存: %s\n", cpuUsageAmount, memoryUsageAmount));

                        if (containerConfigOpt.isPresent()) {
                            io.fabric8.kubernetes.api.model.Container containerConfig = containerConfigOpt.get();
                            ResourceRequirements resources = containerConfig.getResources();

                            if (resources != null) {
                                // CPU 百分比计算
                                Quantity cpuLimit = resources.getLimits() != null ? resources.getLimits().get("cpu") : null;
                                Quantity cpuRequest = resources.getRequests() != null ? resources.getRequests().get("cpu") : null;

                                double currentCpuMillicores = parseCpuToMillicores(new Quantity(cpuUsageAmount, null));
                                double cpuAllocatedMillicores = 0;
                                String cpuBase = "N/A";

                                if (cpuLimit != null) {
                                    cpuAllocatedMillicores = parseCpuToMillicores(cpuLimit);
                                    cpuBase = "限制";
                                } else if (cpuRequest != null) {
                                    cpuAllocatedMillicores = parseCpuToMillicores(cpuRequest);
                                    cpuBase = "请求";
                                }

                                if (cpuAllocatedMillicores > 0) {
                                    double cpuPercentage = (currentCpuMillicores / cpuAllocatedMillicores) * 100;
                                    result.append(String.format("  CPU 占用百分比: %.2f%% (基于%s: %s)\n", cpuPercentage, cpuBase,
                                            cpuBase.equals("限制") ? cpuLimit.getAmount() : cpuRequest.getAmount()));
                                    if (cpuPercentage >= 80.0) {
                                        result.append("  ⚠️ **警告: CPU 使用率过高！**\n");
                                    }
                                } else {
                                    result.append("  CPU 占用百分比: 无法计算 (未设置 CPU 请求或限制)\n");
                                }

                                // 内存百分比计算
                                Quantity memoryLimit = resources.getLimits() != null ? resources.getLimits().get("memory") : null;
                                Quantity memoryRequest = resources.getRequests() != null ? resources.getRequests().get("memory") : null;

                                long currentMemoryBytes = parseMemoryToBytes(new Quantity(memoryUsageAmount, null));
                                long memoryAllocatedBytes = 0;
                                String memoryBase = "N/A";

                                if (memoryLimit != null) {
                                    memoryAllocatedBytes = parseMemoryToBytes(memoryLimit);
                                    memoryBase = "限制";
                                } else if (memoryRequest != null) {
                                    memoryAllocatedBytes = parseMemoryToBytes(memoryRequest);
                                    memoryBase = "请求";
                                }

                                if (memoryAllocatedBytes > 0) {
                                    double memoryPercentage = ((double) currentMemoryBytes / memoryAllocatedBytes) * 100;
                                    result.append(String.format("  内存占用百分比: %.2f%% (基于%s: %s)\n", memoryPercentage, memoryBase,
                                            memoryBase.equals("限制") ? memoryLimit.getAmount() : memoryRequest.getAmount()));
                                    if (memoryPercentage >= 80.0) {
                                        result.append("  ⚠️ **警告: 内存使用率过高！**\n");
                                    }
                                } else {
                                    result.append("  内存占用百分比: 无法计算 (未设置内存请求或限制)\n");
                                }
                            } else {
                                result.append("  未定义资源请求和限制，无法计算百分比。\n");
                            }
                        } else {
                            result.append("  未找到容器配置信息，无法计算百分比。\n");
                        }
                    }
                } else {
                    result.append("⚠️ **未找到容器资源使用详情**。\n");
                }

                return result.toString();
            }
        } catch (KubernetesClientException e) {
            log.error("获取 Pod {} 资源使用情况失败: {}", podName, e.getMessage(), e);
            return String.format("❌ **获取 Pod '%s' 资源使用情况失败**: %s", podName, e.getMessage());
        } catch (Exception e) {
            log.error("获取 Pod {} 资源使用情况时发生未知错误: {}", podName, e.getMessage(), e);
            return String.format("❌ **获取 Pod '%s' 资源使用情况时发生未知错误**: %s", podName, e.getMessage());
        }
    }

    @Tool(description = "在指定命名空间中查找CPU或内存使用率最高的Pod。当用户想知道'哪个Pod资源占用高'或'检查资源使用'等模糊问题时非常有用。")
    public String findTopResourceConsumingPods(String namespace, int topN) {
        if (topN <= 0) {
            topN = 3; // 默认查找前3名
        }
        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("📊 正在查找命名空间 '{}' 中资源使用率最高的前 {} 个 Pod", targetNamespace, topN);

        try (KubernetesClient client = KubernetesClientUtil.getClient()) {
            // 1. 获取命名空间下所有Pod的指标
            PodMetricsList podMetricsList = client.top().pods().inNamespace(targetNamespace).metrics();

            if (podMetricsList == null || podMetricsList.getItems().isEmpty()) {
                return String.format("⚠️ 在命名空间 '%s' 中未找到任何 Pod 的度量数据。请检查 Metrics Server 是否正常运行。", targetNamespace);
            }

            // 2. 按CPU使用率排序
            List<PodMetrics> sortedByCpu = podMetricsList.getItems().stream()
                    .sorted((p1, p2) -> {
                        long cpu1 = p1.getContainers().stream().mapToLong(c -> parseCpuToNanoCores(c.getUsage().get("cpu"))).sum();
                        long cpu2 = p2.getContainers().stream().mapToLong(c -> parseCpuToNanoCores(c.getUsage().get("cpu"))).sum();
                        return Long.compare(cpu2, cpu1); // 降序
                    })
                    .limit(topN)
                    .collect(Collectors.toList());

            // (可以按内存再排一次序，这里为了简化，只用了CPU)

            // 3. 格式化输出
            StringBuilder result = new StringBuilder();
            result.append(String.format("📈 **命名空间 '%s' 中CPU使用率最高的 Pod**:\n\n", targetNamespace));

            for (PodMetrics pm : sortedByCpu) {
                String podName = pm.getMetadata().getName();
                long totalCpuNano = pm.getContainers().stream().mapToLong(c -> parseCpuToNanoCores(c.getUsage().get("cpu"))).sum();
                long totalMemoryBytes = pm.getContainers().stream().mapToLong(c -> parseMemoryToBytes(c.getUsage().get("memory"))).sum();
                result.append(String.format("- **Pod**: %s\n", podName));
                result.append(String.format("  - **CPU**: %.2f m\n", totalCpuNano / 1_000_000.0)); // 转换为毫核
                result.append(String.format("  - **内存**: %s\n", formatBytes(totalMemoryBytes)));
            }

            result.append("\n💡 **下一步**: 您可以使用 `getPodResourceUsage` 或 `describePod` 工具，并提供上述Pod名称以获取更详细的信息。");

            return result.toString();
        } catch (Exception e) {
            log.error("查找资源使用率高的 Pod 失败: {}", e.getMessage(), e);
            return String.format("❌ 执行查找失败: %s", e.getMessage());
        }
    }

    // 需要在类中添加这两个辅助方法
    private long parseCpuToNanoCores(Quantity cpuQuantity) {
        if (cpuQuantity == null || cpuQuantity.getAmount() == null) return 0L;
        String amount = cpuQuantity.getAmount();
        if (amount.endsWith("n")) {
            return Long.parseLong(amount.substring(0, amount.length() - 1));
        }
        if (amount.endsWith("u")) { // microcores
            return Long.parseLong(amount.substring(0, amount.length() - 1)) * 1000;
        }
        if (amount.endsWith("m")) { // millicores
            return Long.parseLong(amount.substring(0, amount.length() - 1)) * 1_000_000;
        }
        // full cores
        return (long) (Double.parseDouble(amount) * 1_000_000_000);
    }



    // --- 第二个工具：获取指定Pod的CPU和内存请求与限制 ---
    /**
     * 获取指定Pod的CPU和内存的请求（requests）和限制（limits）配置。
     * 这对于评估Pod是否被正确配置资源，以及是否可能因资源不足或限制过低而导致性能问题非常重要。
     *
     * @param podName Pod的名称
     * @param namespace Pod所在的命名空间
     * @return 包含Pod资源请求和限制的字符串描述
     */

    @Tool(description = "获取指定Pod的CPU和内存的请求（requests）和限制（limits）配置。这对于评估Pod是否被正确配置资源，以及是否可能因资源不足或限制过低而导致性能问题非常重要。")
    public String getPodResourceRequestsAndLimits(String podName, String namespace) {
        if (podName == null || podName.trim().isEmpty()) {
            return "❌ **Pod 名称不能为空**。";
        }
        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("📊 获取 Pod 资源请求与限制 - {}:{}", targetNamespace, podName);

        try {
            // 步骤1: 检查与集群的连接性
            if (!KubernetesClientUtil.testConnection()) {
                return "❌ **集群连接失败**，无法获取 Pod 资源请求与限制。";
            }

            // 步骤2: 获取 Kubernetes 客户端实例
            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                // 步骤3: 获取 Pod 对象（请求和限制在 Pod.spec 中）
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                // 步骤4: 检查是否获取到 Pod
                if (pod == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**。", podName, targetNamespace);
                }

                // 步骤5: 格式化并构建结果字符串
                StringBuilder result = new StringBuilder();
                result.append(String.format("📋 **Pod 资源请求与限制**: %s (命名空间: %s)\n\n", podName, targetNamespace));

                // 遍历 Pod 中的所有容器，获取它们的资源请求和限制
                if (pod.getSpec() != null && pod.getSpec().getContainers() != null && !pod.getSpec().getContainers().isEmpty()) {
                    for (io.fabric8.kubernetes.api.model.Container container : pod.getSpec().getContainers()) {
                        result.append(String.format("--- **容器 '%s'** ---\n", container.getName()));
                        ResourceRequirements resources = container.getResources();

                        if (resources != null) {
                            // 请求 (Requests)
                            if (resources.getRequests() != null && !resources.getRequests().isEmpty()) {
                                result.append("  **请求 (Requests)**:\n");
                                for (Map.Entry<String, Quantity> entry : resources.getRequests().entrySet()) {
                                    result.append(String.format("    - %s: %s\n", entry.getKey(), entry.getValue().getAmount()));
                                }
                            } else {
                                result.append("  **请求 (Requests)**: 未定义\n");
                            }

                            // 限制 (Limits)
                            if (resources.getLimits() != null && !resources.getLimits().isEmpty()) {
                                result.append("  **限制 (Limits)**:\n");
                                for (Map.Entry<String, Quantity> entry : resources.getLimits().entrySet()) {
                                    result.append(String.format("    - %s: %s\n", entry.getKey(), entry.getValue().getAmount()));
                                }
                            } else {
                                result.append("  **限制 (Limits)**: 未定义\n");
                            }
                        } else {
                            result.append("  **未定义资源请求和限制**。\n");
                        }
                        result.append("\n"); // 每个容器后加一个空行
                    }
                } else {
                    result.append("⚠️ **未找到容器资源定义**。\n");
                }

                return result.toString();
            }
        } catch (KubernetesClientException e) {
            log.error("获取 Pod {} 资源请求与限制失败: {}", podName, e.getMessage(), e);
            return String.format("❌ **获取 Pod '%s' 资源请求与限制失败**: %s", podName, e.getMessage());
        } catch (Exception e) {
            log.error("获取 Pod {} 资源请求与限制时发生未知错误: {}", podName, e.getMessage(), e);
            return String.format("❌ **获取 Pod '%s' 资源请求与限制时发生未知错误**: %s", podName, e.getMessage());
        }
    }

    /**
     * 增加指定Pod中容器的CPU请求和/或限制。
     * 这有助于解决因CPU资源不足导致的Pod性能问题或崩溃。
     * 如果只提供requests，则只修改requests；如果只提供limits，则只修改limits；如果都提供，则都修改。
     * CPU值可以使用"m"（毫核）或整数（核心）表示，例如"500m"或"1"。
     *
     * @param podName Pod的名称。
     * @param namespace Pod所在的命名空间。
     * @param containerName 需要修改的容器名称。
     * @param newCpuRequestString 新的CPU请求值（可选，如"500m"或"1"）。
     * @param newCpuLimitString 新的CPU限制值（可选，如"1000m"或"2"）。
     * @return 操作结果的消息。
     */
    @Tool(description = "增加指定Pod中容器的CPU请求和/或限制。这有助于解决因CPU资源不足导致的Pod性能问题或崩溃。CPU值可以使用'm'（毫核）或整数（核心）表示，例如'500m'或'1'。")
    public String scaleUpPodCpu(String podName, String namespace, String containerName,
                                String newCpuRequestString, String newCpuLimitString) {
        if (podName == null || podName.trim().isEmpty() || containerName == null || containerName.trim().isEmpty()) {
            return "❌ **Pod 名称和容器名称不能为空**。";
        }
        if ((newCpuRequestString == null || newCpuRequestString.trim().isEmpty()) &&
                (newCpuLimitString == null || newCpuLimitString.trim().isEmpty())) {
            return "❌ **必须提供新的 CPU 请求或 CPU 限制至少一个**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🚀 尝试增加 Pod '{}' (命名空间: {}) 中容器 '{}' 的 CPU：请求 '{}', 限制 '{}'",
                podName, targetNamespace, containerName, newCpuRequestString, newCpuLimitString);

        try {
            if (!KubernetesClientUtil.testConnection()) {
                return "❌ **集群连接失败**，无法修改 Pod 资源。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                // 1. 获取 Pod 的最新状态
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (pod == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**。", podName, targetNamespace);
                }

                boolean containerFound = false;
                for (Container container : pod.getSpec().getContainers()) {
                    if (container.getName().equals(containerName)) {
                        containerFound = true;
                        // 确保 resources 对象不为空
                        if (container.getResources() == null) {
                            container.setResources(new ResourceRequirements());
                        }

                        // 初始化 requests 和 limits map，如果它们是空的
                        if (container.getResources().getRequests() == null) {
                            container.getResources().setRequests(new java.util.HashMap<>());
                        }
                        if (container.getResources().getLimits() == null) {
                            container.getResources().setLimits(new java.util.HashMap<>());
                        }

                        // 更新 CPU 请求
                        if (newCpuRequestString != null && !newCpuRequestString.trim().isEmpty()) {
                            // 简单的验证，确保是有效的数量格式 (例如 "100m" 或 "1")
                            if (!newCpuRequestString.matches("^\\d+(m)?$")) {
                                return String.format("❌ 无效的 CPU 请求值 '%s'。请使用例如 '500m' 或 '1'。", newCpuRequestString);
                            }
                            container.getResources().getRequests().put("cpu", new Quantity(newCpuRequestString, null));
                            log.debug("更新容器 '{}' 的 CPU 请求为: {}", containerName, newCpuRequestString);
                        }

                        // 更新 CPU 限制
                        if (newCpuLimitString != null && !newCpuLimitString.trim().isEmpty()) {
                            // 简单的验证
                            if (!newCpuLimitString.matches("^\\d+(m)?$")) {
                                return String.format("❌ 无效的 CPU 限制值 '%s'。请使用例如 '1000m' 或 '2'。", newCpuLimitString);
                            }
                            container.getResources().getLimits().put("cpu", new Quantity(newCpuLimitString, null));
                            log.debug("更新容器 '{}' 的 CPU 限制为: {}", containerName, newCpuLimitString);
                        }
                        break; // 找到并更新了容器，退出循环
                    }
                }

                if (!containerFound) {
                    return String.format("❌ Pod '%s' (命名空间: %s) 中未找到容器 '%s'。", podName, targetNamespace, containerName);
                }

                // 2. 应用修改后的 Pod 配置
                // 注意：直接修改 Pod 的 spec 可能会导致 Pod 重启。这是期望的行为，以应用新的资源配置。
                Pod updatedPod = client.pods().inNamespace(targetNamespace).resource(pod).patch();

                if (updatedPod != null) {
                    return String.format("✅ **成功增加 Pod '%s' (命名空间: %s) 中容器 '%s' 的 CPU 资源**。" +
                                    "新的 CPU 请求: %s, 新的 CPU 限制: %s。Pod 可能会重启以应用新配置。",
                            podName, targetNamespace, containerName,
                            (newCpuRequestString != null && !newCpuRequestString.trim().isEmpty()) ? newCpuRequestString : "未修改",
                            (newCpuLimitString != null && !newCpuLimitString.trim().isEmpty()) ? newCpuLimitString : "未修改");
                } else {
                    return String.format("❌ **未能成功增加 Pod '%s' (命名空间: %s) 中容器 '%s' 的 CPU 资源**。请检查 Pod 状态或权限。",
                            podName, targetNamespace, containerName);
                }

            }
        } catch (KubernetesClientException e) {
            log.error("增加 Pod {} 容器 {} 的 CPU 失败: {}", podName, containerName, e.getMessage(), e);
            return String.format("❌ **增加 Pod '%s' 中容器 '%s' 的 CPU 失败**: %s", podName, containerName, e.getMessage());
        } catch (Exception e) {
            log.error("增加 Pod {} 容器 {} 的 CPU 时发生未知错误: {}", podName, containerName, e.getMessage(), e);
            return String.format("❌ **增加 Pod '%s' 中容器 '%s' 的 CPU 时发生未知错误**: %s", podName, containerName, e.getMessage());
        }
    }

    /**
     * 增加指定Pod中容器的内存请求和/或限制。
     * 这有助于解决因内存不足导致的Pod崩溃（OOMKilled）或性能问题。
     * 内存值可以使用K、M、G、Ki、Mi、Gi等后缀表示，例如"256Mi"或"1Gi"。
     * 如果只提供requests，则只修改requests；如果只提供limits，则只修改limits；如果都提供，则都修改。
     *
     * @param podName Pod的名称。
     * @param namespace Pod所在的命名空间。
     * @param containerName 需要修改的容器名称。
     * @param newMemoryRequestString 新的内存请求值（可选，如"256Mi"或"1Gi"）。
     * @param newMemoryLimitString 新的内存限制值（可选，如"512Mi"或"2Gi"）。
     * @return 操作结果的消息。
     */
    @Tool(description = "增加指定Pod中容器的内存请求和/或限制。这有助于解决因内存不足导致的Pod崩溃（OOMKilled）或性能问题。内存值可以使用K、M、G、Ki、Mi、Gi等后缀表示，例如'256Mi'或'1Gi'。")
    public String scaleUpPodMemory(String podName, String namespace, String containerName,
                                   String newMemoryRequestString, String newMemoryLimitString) {
        if (podName == null || podName.trim().isEmpty() || containerName == null || containerName.trim().isEmpty()) {
            return "❌ **Pod 名称和容器名称不能为空**。";
        }
        if ((newMemoryRequestString == null || newMemoryRequestString.trim().isEmpty()) &&
                (newMemoryLimitString == null || newMemoryLimitString.trim().isEmpty())) {
            return "❌ **必须提供新的内存请求或内存限制至少一个**。";
        }

        String targetNamespace = (namespace == null || namespace.trim().isEmpty()) ? DEFAULT_NAMESPACE : namespace;
        log.info("🚀 尝试增加 Pod '{}' (命名空间: {}) 中容器 '{}' 的内存：请求 '{}', 限制 '{}'",
                podName, targetNamespace, containerName, newMemoryRequestString, newMemoryLimitString);

        try {
            if (!KubernetesClientUtil.testConnection()) {
                return "❌ **集群连接失败**，无法修改 Pod 资源。";
            }

            try (KubernetesClient client = KubernetesClientUtil.getClient()) {
                // 1. 获取 Pod 的最新状态
                Pod pod = client.pods().inNamespace(targetNamespace).withName(podName).get();

                if (pod == null) {
                    return String.format("❌ **Pod '%s' 在命名空间 '%s' 中不存在**。", podName, targetNamespace);
                }

                boolean containerFound = false;
                for (Container container : pod.getSpec().getContainers()) {
                    if (container.getName().equals(containerName)) {
                        containerFound = true;
                        // 确保 resources 对象不为空
                        if (container.getResources() == null) {
                            container.setResources(new ResourceRequirements());
                        }

                        // 初始化 requests 和 limits map，如果它们是空的
                        if (container.getResources().getRequests() == null) {
                            container.getResources().setRequests(new java.util.HashMap<>());
                        }
                        if (container.getResources().getLimits() == null) {
                            container.getResources().setLimits(new java.util.HashMap<>());
                        }

                        // 更新内存请求
                        if (newMemoryRequestString != null && !newMemoryRequestString.trim().isEmpty()) {
                            // 简单的验证，确保是有效的数量格式 (例如 "256Mi" 或 "1G")
                            if (!newMemoryRequestString.matches("^\\d+(E|P|T|G|M|K|Ei|Pi|Ti|Gi|Mi|Ki)?$")) {
                                return String.format("❌ 无效的内存请求值 '%s'。请使用例如 '256Mi' 或 '1Gi'。", newMemoryRequestString);
                            }
                            container.getResources().getRequests().put("memory", new Quantity(newMemoryRequestString, null));
                            log.debug("更新容器 '{}' 的内存请求为: {}", containerName, newMemoryRequestString);
                        }

                        // 更新内存限制
                        if (newMemoryLimitString != null && !newMemoryLimitString.trim().isEmpty()) {
                            // 简单的验证
                            if (!newMemoryLimitString.matches("^\\d+(E|P|T|G|M|K|Ei|Pi|Ti|Gi|Mi|Ki)?$")) {
                                return String.format("❌ 无效的内存限制值 '%s'。请使用例如 '512Mi' 或 '2Gi'。", newMemoryLimitString);
                            }
                            container.getResources().getLimits().put("memory", new Quantity(newMemoryLimitString, null));
                            log.debug("更新容器 '{}' 的内存限制为: {}", containerName, newMemoryLimitString);
                        }
                        break; // 找到并更新了容器，退出循环
                    }
                }

                if (!containerFound) {
                    return String.format("❌ Pod '%s' (命名空间: %s) 中未找到容器 '%s'。", podName, targetNamespace, containerName);
                }

                // 2. 应用修改后的 Pod 配置
                // 注意：直接修改 Pod 的 spec 可能会导致 Pod 重启。这是期望的行为，以应用新的资源配置。
                Pod updatedPod = client.pods().inNamespace(targetNamespace).resource(pod).patch();

                if (updatedPod != null) {
                    return String.format("✅ **成功增加 Pod '%s' (命名空间: %s) 中容器 '%s' 的内存资源**。" +
                                    "新的内存请求: %s, 新的内存限制: %s。Pod 可能会重启以应用新配置。",
                            podName, targetNamespace, containerName,
                            (newMemoryRequestString != null && !newMemoryRequestString.trim().isEmpty()) ? newMemoryRequestString : "未修改",
                            (newMemoryLimitString != null && !newMemoryLimitString.trim().isEmpty()) ? newMemoryLimitString : "未修改");
                } else {
                    return String.format("❌ **未能成功增加 Pod '%s' (命名空间: %s) 中容器 '%s' 的内存资源**。请检查 Pod 状态或权限。",
                            podName, targetNamespace, containerName);
                }

            }
        } catch (KubernetesClientException e) {
            log.error("增加 Pod {} 容器 {} 的内存失败: {}", podName, containerName, e.getMessage(), e);
            return String.format("❌ **增加 Pod '%s' 中容器 '%s' 的内存失败**: %s", podName, containerName, e.getMessage());
        } catch (Exception e) {
            log.error("增加 Pod {} 容器 {} 的内存时发生未知错误: {}", podName, containerName, e.getMessage(), e);
            return String.format("❌ **增加 Pod '%s' 中容器 '%s' 的内存时发生未知错误**: %s", podName, containerName, e.getMessage());
        }
    }

    // --- 辅助方法（这些辅助方法在第一个工具中也已包含，确保它们在文件末尾或适当位置存在）---
    /**
     * 将Kubernetes Quantity格式的CPU值解析为毫核（m）。
     * 例如："100m" -> 100, "1" -> 1000
     * @param cpuQuantity CPU数量对象
     * @return 毫核数量
     */
    private double parseCpuToMillicores(Quantity cpuQuantity) {
        if (cpuQuantity == null || cpuQuantity.getAmount() == null || cpuQuantity.getAmount().isEmpty()) {
            return 0.0;
        }
        String amount = cpuQuantity.getAmount();
        if (amount.endsWith("m")) {
            return Double.parseDouble(amount.substring(0, amount.length() - 1));
        } else {
            return Double.parseDouble(amount) * 1000;
        }
    }

    /**
     * 将Kubernetes Quantity格式的内存值解析为字节（Bytes）。
     * 例如："100Mi" -> 104857600, "1Gi" -> 1073741824
     * @param memoryQuantity 内存数量对象
     * @return 字节数
     */
    private long parseMemoryToBytes(Quantity memoryQuantity) {
        if (memoryQuantity == null || memoryQuantity.getAmount() == null || memoryQuantity.getAmount().isEmpty()) {
            return 0L;
        }
        String amount = memoryQuantity.getAmount();
        if (amount.endsWith("Mi")) {
            return (long) (Double.parseDouble(amount.substring(0, amount.length() - 2)) * 1024 * 1024);
        } else if (amount.endsWith("Gi")) {
            return (long) (Double.parseDouble(amount.substring(0, amount.length() - 2)) * 1024 * 1024 * 1024);
        } else if (amount.endsWith("Ki")) {
            return (long) (Double.parseDouble(amount.substring(0, amount.length() - 2)) * 1024);
        } else if (amount.endsWith("G")) {
            return (long) (Double.parseDouble(amount.substring(0, amount.length() - 1)) * 1000 * 1000 * 1000);
        } else if (amount.endsWith("M")) {
            return (long) (Double.parseDouble(amount.substring(0, amount.length() - 1)) * 1000 * 1000);
        } else if (amount.endsWith("K")) {
            return (long) (Double.parseDouble(amount.substring(0, amount.length() - 1)) * 1000);
        }else {
            try {
                return Long.parseLong(amount);
            } catch (NumberFormatException e) {
                log.warn("无法解析的内存数量字符串: {}", amount);
                return 0L;
            }
        }
    }

    /**
     * 格式化字节数为更易读的单位 (KiB, MiB, GiB)。
     * @param bytes 字节数
     * @return 格式化后的字符串
     */
    private String formatBytes(long bytes) {
        if (bytes < 0) return "N/A";
        if (bytes < 1024) {
            return bytes + "B";
        }
        double value = (double) bytes;
        if (value < 1024 * 1024) {
            return String.format("%.1fKi", value / 1024);
        } else if (value < 1024 * 1024 * 1024) {
            return String.format("%.1fMi", value / (1024 * 1024));
        } else {
            return String.format("%.1fGi", value / (1024 * 1024 * 1024));
        }
    }
}
